﻿// 贴片电阻电容计算器.cpp : 定义应用程序的入口点。
//

#define _CRT_SECURE_NO_WARNINGS
#include <windows.h>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>
#include <map>
#include <commctrl.h>

// 定义控件ID
#define ID_EDIT_CODE 101
#define ID_EDIT_VALUE 102
#define ID_BUTTON_CALC 103
#define ID_BUTTON_FIND 104
#define ID_EDIT_RESULT 105

// 全局变量:
HINSTANCE hInst;                                // 当前实例

// 定义E96标准阻值表
const std::vector<double> E96_VALUES = {
    10.0, 10.2, 10.5, 10.7, 11.0, 11.3, 11.5, 11.8, 12.1, 12.4, 12.7, 13.0,
    13.3, 13.7, 14.0, 14.3, 14.7, 15.0, 15.4, 15.8, 16.2, 16.5, 16.9, 17.4,
    17.8, 18.2, 18.7, 19.1, 19.6, 20.0, 20.5, 21.0, 21.5, 22.1, 22.6, 23.2,
    23.7, 24.3, 24.9, 25.5, 26.1, 26.7, 27.4, 28.0, 28.7, 29.4, 30.1, 30.9,
    31.6, 32.4, 33.2, 34.0, 34.8, 35.7, 36.5, 37.4, 38.3, 39.2, 40.2, 41.2,
    42.2, 43.2, 44.2, 45.3, 46.4, 47.5, 48.7, 49.9, 51.1, 52.3, 53.6, 54.9,
    56.2, 57.6, 59.0, 60.4, 61.9, 63.4, 64.9, 66.5, 68.1, 69.8, 71.5, 73.2,
    75.0, 76.8, 78.7, 80.6, 82.5, 84.5, 86.6, 88.7, 90.9, 93.1, 95.3, 97.6
};

// 定义代码到阻值的映射
const std::map<std::string, int> CODE_TO_MULTIPLIER = {
    {"01", 1}, {"02", 10}, {"03", 100}, {"04", 1000}, {"05", 10000},
    {"06", 100000}, {"07", 1000000}
};

// 定义E24标准阻值表
const std::vector<double> E24_VALUES = {
    10.0, 11.0, 12.0, 13.0, 15.0, 16.0, 18.0, 20.0, 22.0, 24.0, 27.0, 30.0,
    33.0, 36.0, 39.0, 43.0, 47.0, 51.0, 56.0, 62.0, 68.0, 75.0, 82.0, 91.0
};

// E96后缀与倍数映射表
const std::map<char, double> E96_SUFFIX = {
    {'Z', 0.01},
    {'Y', 0.1},
    {'X', 1.0},
    {'A', 10.0},
    {'B', 100.0},
    {'C', 1000.0},
    {'D', 10000.0},
    {'E', 100000.0},
    {'F', 1000000.0}
};

// 函数声明
double calculateResistance(const std::string& code);
double findClosestE96Value(double target);
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
std::string getStandardCode(double value);
double parseResistanceValue(const std::string& input);
std::string getE96Code(double value);

// 查找最接近的E24标准阻值
double findClosestE24Value(double target) {
    double multiplier = 1.0;
    while (target >= 91.0) {
        target /= 10.0;
        multiplier *= 10.0;
    }
    while (target < 10.0) {
        target *= 10.0;
        multiplier /= 10.0;
    }
    double closest = E24_VALUES[0];
    double minDiff = std::abs(target - E24_VALUES[0]);
    for (double value : E24_VALUES) {
        double diff = std::abs(target - value);
        if (diff < minDiff) {
            minDiff = diff;
            closest = value;
        }
    }
    return closest * multiplier;
}

// 获取E24三位贴片代码
std::string getE24Code(double value) {
    char code[8];
    if (value < 1) {
        // 0.47Ω -> R47
        int intVal = static_cast<int>(value * 100 + 0.5);
        sprintf(code, "R%02d", intVal);
        return std::string(code);
    } else if (value < 10) {
        int intVal = static_cast<int>(value);
        int decimal = static_cast<int>((value - intVal) * 100 + 0.5);
        // 1Ω~10Ω整数，显示xR00
        if (decimal == 0) {
            sprintf(code, "%dR00", intVal);
            return std::string(code);
        } else if (decimal % 10 == 0) {
            // 兼容如1.5Ω→1R50
            sprintf(code, "%dR%02d", intVal, decimal);
            return std::string(code);
        } else {
            // 4.7Ω→4R7
            sprintf(code, "%dR%d", intVal, decimal / 10);
            return std::string(code);
        }
    }
    // 整数值，三位代码
    int exponent = 0;
    while (value >= 100) {
        value /= 10.0;
        exponent++;
    }
    int intValue = static_cast<int>(round(value));
    sprintf(code, "%02d%d", intValue, exponent);
    return std::string(code);
}

// 修改计算电阻值函数
double calculateResistance(const std::string& code) {
    if (code.length() < 2 || code.length() > 4) return -1;
    
    double value = 0;

    // 检查是否包含'R'（E24带R小数点支持）
    size_t rPos = code.find('R');
    if (rPos != std::string::npos) {
        // R在任何位置都作为小数点
        std::string numStr = code;
        numStr.erase(rPos, 1);  // 移除R
        
        if (rPos == 0 || (rPos == 1 && code[0] == '0')) {
            // R在最前面(R47)或0R47的情况
            std::string afterR = (rPos == 0) ? numStr : numStr.substr(1);
            value = std::stod("0." + afterR);
        } else if (rPos == code.length() - 1) {
            // R在最后，忽略R，只取前面的数值
            value = std::stod(code.substr(0, rPos));
        } else {
            // 其他情况，如4R7、47R
            value = std::stod(numStr.substr(0, rPos) + "." + numStr.substr(rPos));
        }
        return value;
    }

    // 处理4位精密电阻代码
    if (code.length() == 4) {
        std::string firstThree = code.substr(0, 3);
        char multiplier = code[3];
        
        // 检查是否包含'R'（小数点）
        size_t rPos = firstThree.find('R');
        if (rPos != std::string::npos && rPos != 2) {  // R在中间位置时才作为小数点
            // 例如: 4R7K = 4.7KΩ
            std::string numStr = firstThree;
            numStr.erase(rPos, 1);  // 移除'R'
            value = std::stod(numStr.substr(0, rPos) + "." + numStr.substr(rPos));
            
            // 处理乘数
            switch(multiplier) {
                case 'K': value *= 1000; break;   // KΩ
                case 'M': value *= 1000000; break;// MΩ
                default: return -1;
            }
        } else {
            // 例如: 1001 = 1.00KΩ
            // 或者 100R = 100Ω (R在最后位置时忽略)
            if (firstThree[2] == 'R') {
                value = std::stod(firstThree.substr(0, 2));
            } else {
                value = std::stod(firstThree);
                // 处理乘数
                if (isdigit(multiplier)) {
                    value *= pow(10, multiplier - '0');
                } else {
                    switch(multiplier) {
                        case 'K': value *= 1000; break;   // KΩ
                        case 'M': value *= 1000000; break;// MΩ
                        default: return -1;
                    }
                }
            }
        }
        return value;
    }

    // 处理普通贴片电阻（三个数字）
    if (isdigit(code[0]) && isdigit(code[1]) && isdigit(code[2])) {
        int firstDigit = code[0] - '0';
        int secondDigit = code[1] - '0';
        int multiplier = code[2] - '0';
        
        value = (firstDigit * 10 + secondDigit) * pow(10, multiplier);
        return value;
    }

    // 处理E96系列
    bool isE96 = false;
    int e96Index = -1;
    if (code.length() >= 3) {
        std::string prefix = code.substr(0, 2);
        for (int i = 0; i < 96; ++i) {
            char buf[3];
            sprintf(buf, "%02d", i + 1);
            if (prefix == buf) {
                value = E96_VALUES[i];
                isE96 = true;
                e96Index = i;
                break;
            }
        }
    }
    if (!isE96) {
        return -1;
    }

    // 根据后缀确定单位（支持Z、Y、X、A、B、C、D、E、F）
    if (isE96) {
        char lastChar = code[code.length()-1];
        auto it = E96_SUFFIX.find(lastChar);
        if (it != E96_SUFFIX.end()) {
            value *= it->second;
        } else {
            return -1;
        }
    }
    
    return value;
}

// 查找最接近的标准阻值
double findClosestE96Value(double target) {
    double multiplier = 1.0;
    while (target >= 20.5) {
        target /= 10.0;
        multiplier *= 10.0;
    }
    while (target < 10.0) {
        target *= 10.0;
        multiplier /= 10.0;
    }
    
    double closest = E96_VALUES[0];
    double minDiff = std::abs(target - E96_VALUES[0]);
    
    for (double value : E96_VALUES) {
        double diff = std::abs(target - value);
        if (diff < minDiff) {
            minDiff = diff;
            closest = value;
        }
    }
    
    return closest * multiplier;
}

// 修改获取普通电阻代码的函数
std::string getStandardCode(double value) {
    char code[10];
    if (value >= 100) {
        int exponent = 0;
        while (value >= 1000) {
            value /= 1000;
            exponent += 3;
        }
        int multiplier = exponent / 3 + 2;  // 计算正确的乘数位
        sprintf(code, "%.0f%d", value, multiplier);
    } else {
        int multiplier = 1;  // 小于100的值使用乘数1
        sprintf(code, "%.0f%d", value, multiplier);
    }
    return std::string(code);
}

// 添加一个新函数来解析带单位的电阻值
double parseResistanceValue(const std::string& input) {
    std::string value = input;
    double multiplier = 1.0;
    
    // 转换为大写以统一处理
    std::transform(value.begin(), value.end(), value.begin(), ::toupper);
    
    // 检查单位并设置相应的乘数
    if (value.find("K") != std::string::npos) {
        multiplier = 1000.0;
        value.erase(value.find("K"));
    } else if (value.find("M") != std::string::npos) {
        multiplier = 1000000.0;
        value.erase(value.find("M"));
    }
    
    // 转换数值部分
    return atof(value.c_str()) * multiplier;
}

// 添加一个函数来获取E96代码
std::string getE96Code(double value) {
    // 将值标准化到10-97.6范围内
    int exponent = 0;
    while (value < 10.0) {
        value *= 10.0;
        exponent--;
    }
    while (value > 97.6) {
        value /= 10.0;
        exponent++;
    }
    // 查找匹配的值和代码
    for (int i = 0; i < 96; i++) {
        if (std::abs(value - E96_VALUES[i]) < 0.01) {
            char code[5];
            sprintf(code, "%02d", i + 1);
            // 后缀
            const char suffixes[] = {'Z','Y','X','A','B','C','D','E','F'};
            int suffixIndex = exponent + 2; // -2:Z, -1:Y, 0:X, 1:A, ...
            if (suffixIndex < 0 || suffixIndex > 8) return "";
            char suffix = suffixes[suffixIndex];
            char result[6];
            sprintf(result, "%s%c", code, suffix);
            return std::string(result);
        }
    }
    return "";
}

// 窗口过程
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    static HWND hEditCode, hEditValue, hEditResult;
    static HWND hButtonCalc, hButtonFind;
    
    switch(msg) {
        case WM_CREATE: {
            // 创建更大的字体
            HFONT hFont = CreateFont(20, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE,
                DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, L"微软雅黑");

            // 创建主分组框
            HWND hGroup = CreateWindowW(L"BUTTON", L"电阻计算器", 
                WS_VISIBLE | WS_CHILD | BS_GROUPBOX,
                10, 20, 430, 280, hwnd, NULL, NULL, NULL);
            SendMessage(hGroup, WM_SETFONT, (WPARAM)hFont, TRUE);

            // 创建电阻代码输入框和标签
            CreateWindowW(L"STATIC", L"电阻代码:", WS_VISIBLE | WS_CHILD,
                20, 75, 80, 25, hwnd, NULL, NULL, NULL);
            SendMessage(GetWindow(hwnd, GW_CHILD), WM_SETFONT, (WPARAM)hFont, TRUE);
            
            hEditCode = CreateWindowW(L"EDIT", L"", 
                WS_VISIBLE | WS_CHILD | WS_BORDER | ES_CENTER,
                110, 75, 170, 25, hwnd, (HMENU)ID_EDIT_CODE, NULL, NULL);
            SendMessage(hEditCode, WM_SETFONT, (WPARAM)hFont, TRUE);
            
            hButtonCalc = CreateWindowW(L"BUTTON", L"计算阻值", 
                WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON,
                290, 75, 130, 25, hwnd, (HMENU)ID_BUTTON_CALC, NULL, NULL);
            SendMessage(hButtonCalc, WM_SETFONT, (WPARAM)hFont, TRUE);

            // 创建目标阻值输入框和标签
            CreateWindowW(L"STATIC", L"目标阻值:", WS_VISIBLE | WS_CHILD,
                20, 125, 80, 25, hwnd, NULL, NULL, NULL);
            SendMessage(GetWindow(hwnd, GW_CHILD), WM_SETFONT, (WPARAM)hFont, TRUE);
            
            hEditValue = CreateWindowW(L"EDIT", L"", 
                WS_VISIBLE | WS_CHILD | WS_BORDER | ES_CENTER,
                110, 125, 170, 25, hwnd, (HMENU)ID_EDIT_VALUE, NULL, NULL);
            SendMessage(hEditValue, WM_SETFONT, (WPARAM)hFont, TRUE);
            
            hButtonFind = CreateWindowW(L"BUTTON", L"查找标准值", 
                WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON,
                290, 125, 130, 25, hwnd, (HMENU)ID_BUTTON_FIND, NULL, NULL);
            SendMessage(hButtonFind, WM_SETFONT, (WPARAM)hFont, TRUE);

            // 创建结果显示框
            hEditResult = CreateWindowW(L"EDIT", L"", 
                WS_VISIBLE | WS_CHILD | WS_BORDER | ES_MULTILINE | ES_READONLY | ES_CENTER,
                20, 180, 410, 100, hwnd, (HMENU)ID_EDIT_RESULT, NULL, NULL);
            SendMessage(hEditResult, WM_SETFONT, (WPARAM)hFont, TRUE);

            return 0;
        }
        
        case WM_COMMAND: {
            if (LOWORD(wParam) == ID_BUTTON_CALC) {
                char code[5];
                GetWindowTextA(hEditCode, code, 5);
                
                // 将所有小写字母转换为大写
                for (int i = 0; code[i]; i++) {
                    if (isalpha(code[i]) && islower(code[i])) {
                        code[i] = toupper(code[i]);
                    }
                }
                
                double result = calculateResistance(code);
                
                char buffer[200];
                if (result != -1) {
                    const char* unit;
                    double displayValue;
                    
                    if (result >= 1000000) {
                        displayValue = result/1000000;
                        unit = "MΩ";
                    } else if (result >= 1000) {
                        displayValue = result/1000;
                        unit = "KΩ";
                    } else {
                        displayValue = result;
                        unit = "Ω";
                    }
                    
                    // 自动判断E24/E96代码
                    double standardValueE24 = findClosestE24Value(result);
                    double standardValueE96 = findClosestE96Value(result);
                    std::string e24Code = getE24Code(standardValueE24);
                    std::string e96Code = getE96Code(standardValueE96);
                    char buffer2[256] = "";
                    if (fabs(standardValueE24 - result) < 0.0001) {
                        sprintf(buffer2, "E24代码: %s\r\n", e24Code.c_str());
                    }
                    if (!e96Code.empty() && fabs(standardValueE96 - result) < 0.0001) {
                        sprintf(buffer2 + strlen(buffer2), "E96代码: %s", e96Code.c_str());
                    }
                    if (strlen(buffer2) > 0) {
                        sprintf(buffer, "电阻值: %.3f %s\r\n%s", displayValue, unit, buffer2);
                    } else {
                        sprintf(buffer, "电阻值: %.3f %s", displayValue, unit);
                    }
                } else {
                    sprintf(buffer, "无效的代码");
                }
                SetWindowTextA(hEditResult, buffer);
            }
            else if (LOWORD(wParam) == ID_BUTTON_FIND) {
                char valueStr[20];
                GetWindowTextA(hEditValue, valueStr, 20);
                
                if (strlen(valueStr) > 0) {
                    double inputValue = parseResistanceValue(valueStr);
                    if (inputValue > 0) {
                        // 查找最接近的E24和E96标准值
                        double standardValueE24 = findClosestE24Value(inputValue);
                        double standardValueE96 = findClosestE96Value(inputValue);
                        std::string e24Code = getE24Code(standardValueE24);
                        std::string e96Code = getE96Code(standardValueE96);
                        char buffer[256];
                        // E24显示
                        if (standardValueE24 >= 1000000) {
                            sprintf(buffer, "E24代码: %s (%.2f MΩ)\r\n", e24Code.c_str(), standardValueE24/1000000);
                        } else if (standardValueE24 >= 1000) {
                            sprintf(buffer, "E24代码: %s (%.2f KΩ)\r\n", e24Code.c_str(), standardValueE24/1000);
                        } else {
                            sprintf(buffer, "E24代码: %s (%.2f Ω)\r\n", e24Code.c_str(), standardValueE24);
                        }
                        // E96显示
                        if (!e96Code.empty()) {
                            if (standardValueE96 >= 1000000) {
                                sprintf(buffer + strlen(buffer), "E96代码: %s (%.2f MΩ)", e96Code.c_str(), standardValueE96/1000000);
                            } else if (standardValueE96 >= 1000) {
                                sprintf(buffer + strlen(buffer), "E96代码: %s (%.2f KΩ)", e96Code.c_str(), standardValueE96/1000);
                            } else {
                                sprintf(buffer + strlen(buffer), "E96代码: %s (%.2f Ω)", e96Code.c_str(), standardValueE96);
                            }
                        } else {
                            sprintf(buffer + strlen(buffer), "E96代码: 无");
                        }
                        SetWindowTextA(hEditResult, buffer);
                    } else {
                        SetWindowTextA(hEditResult, "请输入有效的阻值");
                    }
                } else {
                    SetWindowTextA(hEditResult, "");  // 输入框为空时清空结果
                }
            }
            // 修改实时转换功能
            else if (HIWORD(wParam) == EN_CHANGE && LOWORD(wParam) == ID_EDIT_CODE) {
                char code[5];
                GetWindowTextA(hEditCode, code, 5);
                bool changed = false;
                
                // 获取当前光标位置
                DWORD start, end;
                SendMessage(hEditCode, EM_GETSEL, (WPARAM)&start, (LPARAM)&end);
                
                std::string validText;
                // 只保留有效字符（字母和数字）
                for (int i = 0; i < static_cast<int>(strlen(code)); i++) {
                    unsigned char c = static_cast<unsigned char>(code[i]);
                    // 检查是否为ASCII范围内的字母或数字
                    if (c >= 0x20 && c <= 0x7F && isalnum(c)) {
                        if (isalpha(c)) {
                            c = toupper(c);  // 字母转大写
                        }
                        validText += static_cast<char>(c);
                    } else {
                        changed = true;  // 标记需要更新文本
                    }
                }
                
                // 如果有无效字符或需要转换大小写
                if (changed || validText != code) {
                    // 更新编辑框文本
                    SetWindowTextA(hEditCode, validText.c_str());
                    // 恢复光标位置（考虑可能的字符删除）
                    SendMessage(hEditCode, EM_SETSEL, 
                        min(start, validText.length()), 
                        min(end, validText.length()));
                }
            }
            // 在 WM_COMMAND 中添加对 ID_EDIT_VALUE 的处理
            else if (HIWORD(wParam) == EN_CHANGE && LOWORD(wParam) == ID_EDIT_VALUE) {
                char valueStr[20];
                GetWindowTextA(hEditValue, valueStr, 20);
                
                if (strlen(valueStr) > 0) {
                    double inputValue = parseResistanceValue(valueStr);
                    if (inputValue > 0) {
                        double standardValueE24 = findClosestE24Value(inputValue);
                        double standardValueE96 = findClosestE96Value(inputValue);
                        std::string e24Code = getE24Code(standardValueE24);
                        std::string e96Code = getE96Code(standardValueE96);
                        char buffer[256];
                        if (fabs(standardValueE24 - inputValue) < 0.0001) {
                            if (standardValueE24 >= 1000000) {
                                sprintf(buffer, "E24代码: %s (%.2f MΩ)\r\n", e24Code.c_str(), standardValueE24/1000000);
                            } else if (standardValueE24 >= 1000) {
                                sprintf(buffer, "E24代码: %s (%.2f KΩ)\r\n", e24Code.c_str(), standardValueE24/1000);
                            } else {
                                sprintf(buffer, "E24代码: %s (%.2f Ω)\r\n", e24Code.c_str(), standardValueE24);
                            }
                        } else {
                            sprintf(buffer, "不是E24标准阻值\r\n");
                        }
                        if (fabs(standardValueE96 - inputValue) < 0.0001) {
                            if (!e96Code.empty()) {
                                if (standardValueE96 >= 1000000) {
                                    sprintf(buffer + strlen(buffer), "E96代码: %s (%.2f MΩ)", e96Code.c_str(), standardValueE96/1000000);
                                } else if (standardValueE96 >= 1000) {
                                    sprintf(buffer + strlen(buffer), "E96代码: %s (%.2f KΩ)", e96Code.c_str(), standardValueE96/1000);
                                } else {
                                    sprintf(buffer + strlen(buffer), "E96代码: %s (%.2f Ω)", e96Code.c_str(), standardValueE96);
                                }
                            } else {
                                sprintf(buffer + strlen(buffer), "E96代码: 无");
                            }
                        } else {
                            sprintf(buffer + strlen(buffer), "不是E96标准阻值");
                        }
                        SetWindowTextA(hEditResult, buffer);
                    } else {
                        SetWindowTextA(hEditResult, "请输入有效的阻值");
                    }
                } else {
                    SetWindowTextA(hEditResult, "");
                }
            }
            return 0;
        }
        
    case WM_DESTROY:
        PostQuitMessage(0);
            return 0;

        case WM_CTLCOLORBTN:
            return (LRESULT)CreateSolidBrush(RGB(240, 240, 240));

        case WM_CTLCOLORSTATIC:
            SetBkMode((HDC)wParam, TRANSPARENT);
            return (LRESULT)GetStockObject(WHITE_BRUSH);

        case WM_CTLCOLOREDIT: {
            HDC hdcEdit = (HDC)wParam;
            SetBkMode(hdcEdit, OPAQUE);
            SetBkColor(hdcEdit, RGB(255, 255, 255));
            SetTextColor(hdcEdit, RGB(0, 0, 0));
            return (LRESULT)GetStockObject(WHITE_BRUSH);
        }
    }
    return DefWindowProc(hwnd, msg, wParam, lParam);
}

// 程序入口点
int WINAPI WinMain(
    _In_ HINSTANCE hInstance,
    _In_opt_ HINSTANCE hPrevInstance,
    _In_ LPSTR lpCmdLine,
    _In_ int nCmdShow)
{
    hInst = hInstance; // 保存实例句柄
    
    // 注册窗口类
    WNDCLASSW wc = {0};
    wc.lpfnWndProc = WndProc;
    wc.hInstance = hInstance;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
    wc.lpszClassName = L"ResistorCalculator";
    
    if (!RegisterClassW(&wc)) return -1;
    
    // 创建窗口
    HWND hwnd = CreateWindowW(
        L"ResistorCalculator", L"贴片电阻计算器",
        WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
        (GetSystemMetrics(SM_CXSCREEN) - 465) / 2,
        (GetSystemMetrics(SM_CYSCREEN) - 340) / 2,  // 修改窗口高度从470到340
        465, 340,  // 修改窗口高度从470到340
        NULL, NULL, hInstance, NULL);
        
    if (!hwnd) return -1;
    
    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);
    
    // 消息循环
    MSG msg = {0};
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    
    return (int)msg.wParam;
}
